home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / gnu / gnulib / sipp / srgp / src / srgp_pat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-01  |  11.5 KB  |  449 lines
  1. #include "HEADERS.h"
  2. #include "srgplocal.h"
  3. #include "default_patterns.h"
  4.  
  5.  
  6. #define BUFFERSIZE   150
  7.  
  8. static char   inputline [BUFFERSIZE+1];
  9.  
  10. #ifdef X11
  11.    static XImage *ximage_pix, *ximage_bit;
  12.    static GC     putimagegc_pix, putimagegc_bit;
  13. #endif
  14.  
  15.  
  16.  
  17. /** INITIALIZATION OF THE PATTERN TABLE
  18. Bitmap pattern table is initialized; or at least a large portion of
  19. it is initialized.
  20.  
  21. The pixmap pattern table's 0th element is initialized to all 0.
  22. No other pixmap patterns are initialized.
  23.  
  24. WARNING: CURRENTLY THE MAC VERSION INIT'S NO PIXMAPS.
  25.  
  26. This routine also initializes some static variables that are
  27. necessary for making runtime changes to the pixmap table.
  28. **/
  29.  
  30. void
  31. SRGP__initDefaultPatterns()
  32. {
  33.    register i;
  34.  
  35.    /******** bitmap table */
  36.    for (i=0; i <= 104; i++) {
  37. #ifdef X11
  38.       srgp__bitmapPatternTable[i] =
  39.      XCreateBitmapFromData
  40.         (srgpx__display, srgp__canvasTable[0].drawable.win,
  41.          default_bitpat[i], 8, 8);
  42. #endif
  43. #ifdef THINK_C
  44.       memcpy (srgp__bitmapPatternTable[i], default_bitpat[i], (size_t)8);
  45. #endif
  46. #ifdef GRX
  47.       srgp__bitmapPatternTable[i] = (unsigned char *)&default_bitpat[i][0];
  48. #endif
  49.    }
  50.  
  51. #ifdef X11
  52.    for ( ; i <= MAX_PATTERN_INDEX; i++)
  53.       srgp__bitmapPatternTable[i] = NULL;
  54. #endif
  55. #ifdef GRX
  56.    for( ; i <= MAX_PATTERN_INDEX; i++) srgp__bitmapPatternTable[i] = NULL;
  57. #endif
  58.  
  59.  
  60.  
  61.    /******** pixmap table */
  62. #ifdef X11
  63.    srgp__pixmapPatternTable[0] =
  64.       XCreatePixmapFromBitmapData
  65.      (srgpx__display, srgp__canvasTable[0].drawable.win,
  66.       default_bitpat[0], 8, 8,
  67.       COLORINDEX(SRGP_BLACK), COLORINDEX(SRGP_WHITE),
  68.       srgp__available_depth);
  69. #endif
  70. #ifdef THINK_C
  71.    srgp__pixmapPatternTable[0] = NULL;
  72. #endif
  73. #ifdef GRX
  74.    {
  75.     char data[64];
  76.     int  colors[2];
  77.  
  78.     colors[0] = 1;
  79.     colors[1] = COLORINDEX(SRGP_WHITE);
  80.     memset(data,0,64);
  81.     srgp__pixmapPatternTable[0] = GrBuildPixmap(data,8,8,colors);
  82.     if(srgp__pixmapPatternTable[0] == NULL) SRGP__error(ERR_MALLOC);
  83.    }
  84. #endif
  85.  
  86.    for (i=1; i <= MAX_PATTERN_INDEX; i++)
  87.       srgp__pixmapPatternTable[i] = NULL;
  88.  
  89.  
  90. #ifdef X11
  91.    /******** imaging variables */
  92.    putimagegc_pix =
  93.       XCreateGC (srgpx__display, srgp__canvasTable[0].drawable.win,
  94.          0L, NULL);
  95.    putimagegc_bit =
  96.       XCreateGC (srgpx__display, srgp__bitmapPatternTable[0],
  97.          0L, NULL);
  98.    ximage_pix = XGetImage (srgpx__display,
  99.                srgp__pixmapPatternTable[0],
  100.                0,0, 8,8,
  101.                0xffff,
  102.                XYPixmap);
  103.    ximage_bit = XGetImage (srgpx__display,
  104.                srgp__bitmapPatternTable[0],
  105.                0,0, 8,8,
  106.                1,
  107.                XYPixmap);
  108. #endif
  109. }
  110.  
  111.  
  112. #ifdef GRX
  113. extern void srgp__update_grx_penattributes(void);
  114. extern void srgp__update_grx_fillattributes(void);
  115. #endif
  116.  
  117.  
  118.  
  119. /** LOAD A SINGLE BITMAP PATTERN
  120. Application must send data in the form of 8 characters, the
  121. same format created by the X bitmap editor.
  122. **/
  123.  
  124. void SRGP_loadBitmapPattern (int pattern_id, char *data)
  125. {
  126.    register i,j;
  127.  
  128.  
  129.    DEBUG_AIDS{
  130.       SRGP_trace (SRGP_logStream, "SRGP_loadBitmapPattern %d %x\n",
  131.           pattern_id, data);
  132.       srgp_check_system_state();
  133.       LeaveIfNonFatalErr();
  134.    }
  135.  
  136. #ifdef X11
  137.    /* CREATE THE BITMAP (if not already) */
  138.    if (NULL == srgp__bitmapPatternTable[pattern_id])
  139.       srgp__bitmapPatternTable[pattern_id] =
  140.      XCreatePixmap
  141.         (srgpx__display, srgp__canvasTable[0].drawable.win, 8, 8,
  142.          1);
  143.  
  144.    if (NULL == srgp__bitmapPatternTable[pattern_id]) {
  145.       SRGP__error (ERR_PATTERN_ALLOCATION);
  146.       return;
  147.    }
  148.  
  149.    /* PAINT THE PIXELS */
  150.    for (i=0; i<8; i++)
  151.       for (j=7; j>=0; j--)
  152.      XPutPixel (ximage_bit, i,j, (data[i]&(1<<j))?XBLACK:XWHITE);
  153.  
  154.  
  155.    /* PUT THE XIMAGE INTO THE BITMAP */
  156.    XPutImage (srgpx__display,
  157.           srgp__bitmapPatternTable[pattern_id],
  158.           putimagegc_bit,
  159.           ximage_bit,
  160.           0,0, 0,0, 8,8);
  161. #endif
  162.  
  163. #ifdef THINK_C
  164.    memcpy (srgp__bitmapPatternTable[pattern_id], data, 8);
  165. #endif
  166. #ifdef GRX
  167.    /* CREATE THE BITMAP (if not already) */
  168.    if(srgp__bitmapPatternTable[pattern_id] == NULL) {
  169.     static unsigned char *morebitmaps = NULL;
  170.     if(morebitmaps == NULL) {
  171.         morebitmaps = malloc((MAX_PATTERN_INDEX + 1 - 104) * 8);
  172.         if(morebitmaps == NULL) {
  173.         SRGP__error(ERR_PATTERN_ALLOCATION);
  174.         return;
  175.         }
  176.     }
  177.     srgp__bitmapPatternTable[pattern_id] = &morebitmaps[(pattern_id - 104) * 8];
  178.    }
  179.    memcpy(srgp__bitmapPatternTable[pattern_id],data,8);
  180.    srgp__update_grx_penattributes();
  181.    srgp__update_grx_fillattributes();
  182. #endif
  183. }
  184.  
  185.  
  186.  
  187.  
  188. #ifdef X11
  189.  
  190. /** LOAD A SINGLE PIXMAP PATTERN
  191. Application must send data in the form of 8x8 array of integers.
  192. The first integer is the color value for the top-left pixel.
  193. The second integer is for the 2nd pixel on the top row.
  194.    etc.
  195. **/
  196.  
  197. void SRGP_loadPixmapPattern (int pattern_id, int *data)
  198. {
  199.    register i,j;
  200.  
  201.  
  202.    DEBUG_AIDS{
  203.       SRGP_trace (SRGP_logStream, "SRGP_loadPixmapPattern %d %x\n",
  204.           pattern_id, data);
  205.       srgp_check_system_state();
  206.       LeaveIfNonFatalErr();
  207.    }
  208.  
  209.    /* CREATE THE PIXMAP (if not already) */
  210.    if (NULL == srgp__pixmapPatternTable[pattern_id])
  211.       srgp__pixmapPatternTable[pattern_id] =
  212.      XCreatePixmap
  213.         (srgpx__display, srgp__canvasTable[0].drawable.win, 8, 8,
  214.          srgp__available_depth);
  215.    if (NULL == srgp__pixmapPatternTable[pattern_id]) {
  216.       SRGP__error (ERR_PATTERN_ALLOCATION);
  217.       return;
  218.    }
  219.  
  220.    /* PAINT THE PIXELS */
  221.    for (i=0; i<8; i++)
  222.       for (j=7; j>=0; j--)
  223.      XPutPixel (ximage_pix, i,j, XCOLOR(COLORINDEX(data[(i<<3)+j])));
  224.  
  225.  
  226.    /* PUT THE XIMAGE INTO THE PIXMAP */
  227.    XPutImage (srgpx__display,
  228.           srgp__pixmapPatternTable[pattern_id],
  229.           putimagegc_pix,
  230.           ximage_pix,
  231.           0,0, 0,0, 8,8);
  232. }
  233.  
  234. #endif
  235.  
  236.  
  237. #ifdef GRX
  238.  
  239. /** LOAD A SINGLE PIXMAP PATTERN
  240. Application must send data in the form of 8x8 array of integers.
  241. The first integer is the color value for the top-left pixel.
  242. The second integer is for the 2nd pixel on the top row.
  243.    etc.
  244. **/
  245.  
  246. void SRGP_loadPixmapPattern (int pattern_id, int *data)
  247. {
  248.    register int i;
  249.    int colors[65];
  250.    char pixdata[64];
  251.    GrPattern *new;
  252.  
  253.    DEBUG_AIDS{
  254.       SRGP_trace (SRGP_logStream, "SRGP_loadPixmapPattern %d %x\n",
  255.           pattern_id, data);
  256.       srgp_check_system_state();
  257.       LeaveIfNonFatalErr();
  258.    }
  259.    colors[0] = 64;
  260.    for(i = 0; i < 64; i++) {
  261.     pixdata[i] = i;
  262.     colors[i+1] = COLORINDEX(data[i]);
  263.    }
  264.    new = GrBuildPixmap(pixdata,8,8,colors);
  265.    if(new == NULL) {
  266.       SRGP__error(ERR_PATTERN_ALLOCATION);
  267.       return;
  268.    }
  269.    if(srgp__pixmapPatternTable[pattern_id] != NULL)
  270.       GrDestroyPattern(srgp__pixmapPatternTable[pattern_id]);
  271.    srgp__pixmapPatternTable[pattern_id] = new;
  272.    srgp__update_grx_penattributes();
  273.    srgp__update_grx_fillattributes();
  274. }
  275.  
  276. #endif
  277.  
  278.  
  279.  
  280. /** LOAD BITMAP PATTERNS
  281. This command reads from an input stream (already
  282. opened by the caller) that should contain one or more bitmap pattern specs.
  283. It reads until EOF is seen, or until any parsing error occurs.
  284.  
  285. Each spec must occupy exactly two lines.  The first line must look like this:
  286.  
  287. static char bitpat_X[] = {
  288.  
  289. where X is a non-negative integer.
  290.  
  291. The second line must specify 8 hexademical numbers in this format:
  292.  
  293.    0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??};
  294.  
  295. Each 2-hexdigit number is 8 bits and thus describes one "scan line"
  296. of the pattern.
  297.  
  298. This format is compatible with the output of
  299. the X bitmap editor (called, appropriately, "bitmap") AS LONG AS
  300. that editor is invoked in this manner:
  301.  
  302.     bitmap bitpat_X 8x8
  303.  
  304. The output files from several bitmap editing sessions can be concatenated
  305. to form a single file defining many bitmap patterns, to be loaded
  306. in a single call to SRGP_loadBitmapPatterns.
  307.  
  308. As a convenience, any lines beginning with '#' are ignored, but these
  309. comment lines must not interrupt a single two-line spec sequence.
  310.  
  311. The closing of the input stream must be performed by the caller.
  312.  
  313. RETURNS 0 if no problem opening the file and parsing the input.
  314. RETURNS 1 if any problems at all occurred.
  315. **/
  316.  
  317. int
  318. SRGP_loadBitmapPatternsFromFile (stream)
  319. FILE *stream;
  320. {
  321.    int intbit[8];
  322.    char charbit[8];
  323.    int i, pattern_id, retval;
  324.  
  325.  
  326.    DEBUG_AIDS{
  327.       srgp_check_system_state();
  328.       SRGP_trace (SRGP_logStream, "SRGP_loadBitmapPatternsFromFile %x\n",
  329.           stream);
  330.       LeaveIfNonFatalErr();
  331.    }
  332.  
  333.    PUSH_TRACE;
  334.    while (fgets(inputline, BUFFERSIZE, stream)) {   /* WHILE NOT EOF */
  335.  
  336.       /* IGNORE COMMENT LINES. */
  337.       if (inputline[0] == '#')
  338.      continue;
  339.  
  340.       /* PARSE TO FIND PATTERN INDEX. */
  341.       if (sscanf (inputline, "static char bitpat_%d", &pattern_id) != 1)
  342.      return 1;  /* ERROR! spec start doesn't match required format */
  343.  
  344.       /* GET NEXT LINE: IT CONTAINS THE PATTERN BITS. */
  345.       if ( ! fgets(inputline, BUFFERSIZE, stream))
  346.      return 1;  /* ERROR! premature eof */
  347.  
  348.       /* PARSE THE PATTERN BITS LINE */
  349.       retval = sscanf (inputline,
  350.                " 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x",
  351.                &intbit[0], &intbit[1], &intbit[2], &intbit[3],
  352.                &intbit[4], &intbit[5], &intbit[6], &intbit[7]);
  353.       if (retval != 8)
  354.      return 1;  /* ERROR! spec 2nd line doesn't match required format */
  355.  
  356.       /* TRANSFORM THE INT-ARRAY SPEC INTO CHAR-ARRAY SPEC. */
  357.       for (i=0; i<8; i++)
  358.      charbit[i]=intbit[i];
  359.  
  360.       PUSH_TRACE;
  361.       SRGP_loadBitmapPattern (pattern_id, charbit);
  362.       POP_TRACE;
  363.    }
  364.  
  365.    return 0;
  366. }
  367.  
  368.  
  369.  
  370.  
  371.  
  372. #if defined(X11) || defined(GRX)
  373.  
  374. /** LOAD PIXMAP PATTERNS FROM FILE
  375. This command reads from an input stream (already
  376. opened by the caller) that should contain one or more pixmap pattern specs.
  377. It reads until EOF is seen, or until any parsing error occurs.
  378.  
  379. Each spec must occupy exactly nine lines.  The first line must look like this:
  380.  
  381. static int pixpat_X[] = {
  382.  
  383. where X is a non-negative integer.
  384.  
  385. The next eight lines each describes one "scan line" of the pixmap pattern,
  386. looking like this:
  387.  
  388.    ?, ?, ?, ?, ?, ?, ?, ?
  389.  
  390. Each question mark represents a non-negative decimal color-value number.
  391.  
  392. As a convenience, any lines beginning with '#' are ignored, but these
  393. comment lines must not interrupt a single nine-line spec sequence.
  394.  
  395. The closing of the input stream must be performed by the caller.
  396.  
  397. RETURNS 0 if no problem opening the file and parsing the input.
  398. RETURNS 1 if any problems at all occurred.
  399. **/
  400. int
  401. SRGP_loadPixmapPatternsFromFile (stream)
  402. FILE *stream;
  403. {
  404.    register i;
  405.    int pattern_id, retval;
  406.    int data[8][8];
  407.  
  408.  
  409.    DEBUG_AIDS{
  410.       srgp_check_system_state();
  411.       SRGP_trace (SRGP_logStream, "SRGP_loadBitmapPatternsFromFile %x\n",
  412.           stream);
  413.       LeaveIfNonFatalErr();
  414.    }
  415.  
  416.    while (fgets(inputline, BUFFERSIZE, stream)) {   /* WHILE NOT EOF */
  417.  
  418.       /* IGNORE COMMENT LINES. */
  419.       if (inputline[0] == '#')
  420.      continue;
  421.  
  422.       /* PARSE TO FIND PATTERN INDEX. */
  423.       if (sscanf (inputline, "static int pixpat_%d", &pattern_id) != 1)
  424.      return 1;  /* ERROR! spec start doesn't match required format */
  425.  
  426.       /* GET AND PROCESS THE NEXT EIGHT LINES */
  427.       for (i=0; i<8; i++) {
  428.  
  429.      if ( ! fgets(inputline, BUFFERSIZE, stream))
  430.         return 1;  /* ERROR! premature eof */
  431.  
  432.      retval = sscanf (inputline,
  433.               "%d, %d, %d, %d, %d, %d, %d, %d",
  434.               &data[i][0], &data[i][1], &data[i][2], &data[i][3],
  435.               &data[i][4], &data[i][5], &data[i][6], &data[i][7]);
  436.      if (retval != 8)
  437.         return 1;  /* ERROR! spec line doesn't match required format */
  438.       }
  439.  
  440.       PUSH_TRACE;
  441.    SRGP_loadPixmapPattern (pattern_id, &(data[0][0]));
  442.    POP_TRACE;
  443.    }
  444.  
  445.    return 0;
  446. }
  447.  
  448. #endif
  449.